package cn.shopping.core.mapper;

import cn.shopping.common.mapper.CommonMapper;
import cn.shopping.core.dbo.UploadInfoDO;
import org.apache.ibatis.annotations.MapKey;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.util.CollectionUtils;

import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;



/**
 * 代码自动生成，请不要修改，切记！！！
 */
@Mapper
public interface UploadInfoMapper extends CommonMapper<UploadInfoDO,Long> {

        public List<UploadInfoDO> listByOriginalFileName(@Param("originalFileName") String originalFileName,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByOriginalFileName(@Param("originalFileName") String originalFileName,@Param("fieldNames") String[] fieldNames);

        public Integer countByOriginalFileName(@Param("originalFileName") String originalFileName);

        public default UploadInfoDO singleResultByOriginalFileName(String originalFileName,String[] fieldNames){
             List<UploadInfoDO> list=this.listByOriginalFileName(originalFileName,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByOriginalFileName(String originalFileName, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByOriginalFileName(originalFileName,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByOriginalFileName(@Param("updateDO") UploadInfoDO updateDO, @Param("originalFileName") String originalFileName);

        public Integer updateAllFieldsByOriginalFileName(@Param("updateDO") UploadInfoDO updateDO, @Param("originalFileName") String originalFileName);

        public Integer deleteByOriginalFileName( @Param("originalFileName") String originalFileName);




        public List<UploadInfoDO> listByInOriginalFileName(@Param("originalFileNameList") Collection<String> originalFileNameList,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByInOriginalFileName(@Param("originalFileNameList") Collection<String> originalFileNameList,@Param("fieldNames") String[] fieldNames);

        public Integer countByInOriginalFileName(@Param("originalFileNameList") Collection<String> originalFileNameList);

        public default UploadInfoDO singleResultByInOriginalFileName(Collection<String> originalFileNameList,String[] fieldNames){
             List<UploadInfoDO> list=this.listByInOriginalFileName(originalFileNameList,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByInOriginalFileName(Collection<String> originalFileNameList, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByInOriginalFileName(originalFileNameList,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByInOriginalFileName(@Param("updateDO") UploadInfoDO updateDO, @Param("originalFileNameList") Collection<String> originalFileNameList);

        public Integer updateAllFieldsByInOriginalFileName(@Param("updateDO") UploadInfoDO updateDO, @Param("originalFileNameList") Collection<String> originalFileNameList);

        public Integer deleteByInOriginalFileName( @Param("originalFileNameList") Collection<String> originalFileNameList);

        public List<UploadInfoDO> listByFileName(@Param("fileName") String fileName,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByFileName(@Param("fileName") String fileName,@Param("fieldNames") String[] fieldNames);

        public Integer countByFileName(@Param("fileName") String fileName);

        public default UploadInfoDO singleResultByFileName(String fileName,String[] fieldNames){
             List<UploadInfoDO> list=this.listByFileName(fileName,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByFileName(String fileName, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByFileName(fileName,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByFileName(@Param("updateDO") UploadInfoDO updateDO, @Param("fileName") String fileName);

        public Integer updateAllFieldsByFileName(@Param("updateDO") UploadInfoDO updateDO, @Param("fileName") String fileName);

        public Integer deleteByFileName( @Param("fileName") String fileName);




        public List<UploadInfoDO> listByInFileName(@Param("fileNameList") Collection<String> fileNameList,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByInFileName(@Param("fileNameList") Collection<String> fileNameList,@Param("fieldNames") String[] fieldNames);

        public Integer countByInFileName(@Param("fileNameList") Collection<String> fileNameList);

        public default UploadInfoDO singleResultByInFileName(Collection<String> fileNameList,String[] fieldNames){
             List<UploadInfoDO> list=this.listByInFileName(fileNameList,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByInFileName(Collection<String> fileNameList, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByInFileName(fileNameList,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByInFileName(@Param("updateDO") UploadInfoDO updateDO, @Param("fileNameList") Collection<String> fileNameList);

        public Integer updateAllFieldsByInFileName(@Param("updateDO") UploadInfoDO updateDO, @Param("fileNameList") Collection<String> fileNameList);

        public Integer deleteByInFileName( @Param("fileNameList") Collection<String> fileNameList);

        public List<UploadInfoDO> listByFileSuffix(@Param("fileSuffix") String fileSuffix,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByFileSuffix(@Param("fileSuffix") String fileSuffix,@Param("fieldNames") String[] fieldNames);

        public Integer countByFileSuffix(@Param("fileSuffix") String fileSuffix);

        public default UploadInfoDO singleResultByFileSuffix(String fileSuffix,String[] fieldNames){
             List<UploadInfoDO> list=this.listByFileSuffix(fileSuffix,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByFileSuffix(String fileSuffix, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByFileSuffix(fileSuffix,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByFileSuffix(@Param("updateDO") UploadInfoDO updateDO, @Param("fileSuffix") String fileSuffix);

        public Integer updateAllFieldsByFileSuffix(@Param("updateDO") UploadInfoDO updateDO, @Param("fileSuffix") String fileSuffix);

        public Integer deleteByFileSuffix( @Param("fileSuffix") String fileSuffix);




        public List<UploadInfoDO> listByInFileSuffix(@Param("fileSuffixList") Collection<String> fileSuffixList,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByInFileSuffix(@Param("fileSuffixList") Collection<String> fileSuffixList,@Param("fieldNames") String[] fieldNames);

        public Integer countByInFileSuffix(@Param("fileSuffixList") Collection<String> fileSuffixList);

        public default UploadInfoDO singleResultByInFileSuffix(Collection<String> fileSuffixList,String[] fieldNames){
             List<UploadInfoDO> list=this.listByInFileSuffix(fileSuffixList,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByInFileSuffix(Collection<String> fileSuffixList, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByInFileSuffix(fileSuffixList,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByInFileSuffix(@Param("updateDO") UploadInfoDO updateDO, @Param("fileSuffixList") Collection<String> fileSuffixList);

        public Integer updateAllFieldsByInFileSuffix(@Param("updateDO") UploadInfoDO updateDO, @Param("fileSuffixList") Collection<String> fileSuffixList);

        public Integer deleteByInFileSuffix( @Param("fileSuffixList") Collection<String> fileSuffixList);

        public List<UploadInfoDO> listByFilePath(@Param("filePath") String filePath,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByFilePath(@Param("filePath") String filePath,@Param("fieldNames") String[] fieldNames);

        public Integer countByFilePath(@Param("filePath") String filePath);

        public default UploadInfoDO singleResultByFilePath(String filePath,String[] fieldNames){
             List<UploadInfoDO> list=this.listByFilePath(filePath,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByFilePath(String filePath, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByFilePath(filePath,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByFilePath(@Param("updateDO") UploadInfoDO updateDO, @Param("filePath") String filePath);

        public Integer updateAllFieldsByFilePath(@Param("updateDO") UploadInfoDO updateDO, @Param("filePath") String filePath);

        public Integer deleteByFilePath( @Param("filePath") String filePath);




        public List<UploadInfoDO> listByInFilePath(@Param("filePathList") Collection<String> filePathList,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByInFilePath(@Param("filePathList") Collection<String> filePathList,@Param("fieldNames") String[] fieldNames);

        public Integer countByInFilePath(@Param("filePathList") Collection<String> filePathList);

        public default UploadInfoDO singleResultByInFilePath(Collection<String> filePathList,String[] fieldNames){
             List<UploadInfoDO> list=this.listByInFilePath(filePathList,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByInFilePath(Collection<String> filePathList, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByInFilePath(filePathList,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByInFilePath(@Param("updateDO") UploadInfoDO updateDO, @Param("filePathList") Collection<String> filePathList);

        public Integer updateAllFieldsByInFilePath(@Param("updateDO") UploadInfoDO updateDO, @Param("filePathList") Collection<String> filePathList);

        public Integer deleteByInFilePath( @Param("filePathList") Collection<String> filePathList);

        public List<UploadInfoDO> listByFileSize(@Param("fileSize") Long fileSize,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByFileSize(@Param("fileSize") Long fileSize,@Param("fieldNames") String[] fieldNames);

        public Integer countByFileSize(@Param("fileSize") Long fileSize);

        public default UploadInfoDO singleResultByFileSize(Long fileSize,String[] fieldNames){
             List<UploadInfoDO> list=this.listByFileSize(fileSize,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByFileSize(Long fileSize, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByFileSize(fileSize,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByFileSize(@Param("updateDO") UploadInfoDO updateDO, @Param("fileSize") Long fileSize);

        public Integer updateAllFieldsByFileSize(@Param("updateDO") UploadInfoDO updateDO, @Param("fileSize") Long fileSize);

        public Integer deleteByFileSize( @Param("fileSize") Long fileSize);




        public List<UploadInfoDO> listByInFileSize(@Param("fileSizeList") Collection<Long> fileSizeList,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByInFileSize(@Param("fileSizeList") Collection<Long> fileSizeList,@Param("fieldNames") String[] fieldNames);

        public Integer countByInFileSize(@Param("fileSizeList") Collection<Long> fileSizeList);

        public default UploadInfoDO singleResultByInFileSize(Collection<Long> fileSizeList,String[] fieldNames){
             List<UploadInfoDO> list=this.listByInFileSize(fileSizeList,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByInFileSize(Collection<Long> fileSizeList, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByInFileSize(fileSizeList,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByInFileSize(@Param("updateDO") UploadInfoDO updateDO, @Param("fileSizeList") Collection<Long> fileSizeList);

        public Integer updateAllFieldsByInFileSize(@Param("updateDO") UploadInfoDO updateDO, @Param("fileSizeList") Collection<Long> fileSizeList);

        public Integer deleteByInFileSize( @Param("fileSizeList") Collection<Long> fileSizeList);

        public List<UploadInfoDO> listByUploadUserId(@Param("uploadUserId") Long uploadUserId,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByUploadUserId(@Param("uploadUserId") Long uploadUserId,@Param("fieldNames") String[] fieldNames);

        public Integer countByUploadUserId(@Param("uploadUserId") Long uploadUserId);

        public default UploadInfoDO singleResultByUploadUserId(Long uploadUserId,String[] fieldNames){
             List<UploadInfoDO> list=this.listByUploadUserId(uploadUserId,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByUploadUserId(Long uploadUserId, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByUploadUserId(uploadUserId,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByUploadUserId(@Param("updateDO") UploadInfoDO updateDO, @Param("uploadUserId") Long uploadUserId);

        public Integer updateAllFieldsByUploadUserId(@Param("updateDO") UploadInfoDO updateDO, @Param("uploadUserId") Long uploadUserId);

        public Integer deleteByUploadUserId( @Param("uploadUserId") Long uploadUserId);




        public List<UploadInfoDO> listByInUploadUserId(@Param("uploadUserIdList") Collection<Long> uploadUserIdList,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByInUploadUserId(@Param("uploadUserIdList") Collection<Long> uploadUserIdList,@Param("fieldNames") String[] fieldNames);

        public Integer countByInUploadUserId(@Param("uploadUserIdList") Collection<Long> uploadUserIdList);

        public default UploadInfoDO singleResultByInUploadUserId(Collection<Long> uploadUserIdList,String[] fieldNames){
             List<UploadInfoDO> list=this.listByInUploadUserId(uploadUserIdList,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByInUploadUserId(Collection<Long> uploadUserIdList, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByInUploadUserId(uploadUserIdList,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByInUploadUserId(@Param("updateDO") UploadInfoDO updateDO, @Param("uploadUserIdList") Collection<Long> uploadUserIdList);

        public Integer updateAllFieldsByInUploadUserId(@Param("updateDO") UploadInfoDO updateDO, @Param("uploadUserIdList") Collection<Long> uploadUserIdList);

        public Integer deleteByInUploadUserId( @Param("uploadUserIdList") Collection<Long> uploadUserIdList);

        public List<UploadInfoDO> listByFileDetail(@Param("fileDetail") String fileDetail,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByFileDetail(@Param("fileDetail") String fileDetail,@Param("fieldNames") String[] fieldNames);

        public Integer countByFileDetail(@Param("fileDetail") String fileDetail);

        public default UploadInfoDO singleResultByFileDetail(String fileDetail,String[] fieldNames){
             List<UploadInfoDO> list=this.listByFileDetail(fileDetail,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByFileDetail(String fileDetail, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByFileDetail(fileDetail,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByFileDetail(@Param("updateDO") UploadInfoDO updateDO, @Param("fileDetail") String fileDetail);

        public Integer updateAllFieldsByFileDetail(@Param("updateDO") UploadInfoDO updateDO, @Param("fileDetail") String fileDetail);

        public Integer deleteByFileDetail( @Param("fileDetail") String fileDetail);




        public List<UploadInfoDO> listByInFileDetail(@Param("fileDetailList") Collection<String> fileDetailList,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByInFileDetail(@Param("fileDetailList") Collection<String> fileDetailList,@Param("fieldNames") String[] fieldNames);

        public Integer countByInFileDetail(@Param("fileDetailList") Collection<String> fileDetailList);

        public default UploadInfoDO singleResultByInFileDetail(Collection<String> fileDetailList,String[] fieldNames){
             List<UploadInfoDO> list=this.listByInFileDetail(fileDetailList,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByInFileDetail(Collection<String> fileDetailList, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByInFileDetail(fileDetailList,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByInFileDetail(@Param("updateDO") UploadInfoDO updateDO, @Param("fileDetailList") Collection<String> fileDetailList);

        public Integer updateAllFieldsByInFileDetail(@Param("updateDO") UploadInfoDO updateDO, @Param("fileDetailList") Collection<String> fileDetailList);

        public Integer deleteByInFileDetail( @Param("fileDetailList") Collection<String> fileDetailList);

        public List<UploadInfoDO> listByUserIdCreate(@Param("userIdCreate") Long userIdCreate,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByUserIdCreate(@Param("userIdCreate") Long userIdCreate,@Param("fieldNames") String[] fieldNames);

        public Integer countByUserIdCreate(@Param("userIdCreate") Long userIdCreate);

        public default UploadInfoDO singleResultByUserIdCreate(Long userIdCreate,String[] fieldNames){
             List<UploadInfoDO> list=this.listByUserIdCreate(userIdCreate,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByUserIdCreate(Long userIdCreate, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByUserIdCreate(userIdCreate,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByUserIdCreate(@Param("updateDO") UploadInfoDO updateDO, @Param("userIdCreate") Long userIdCreate);

        public Integer updateAllFieldsByUserIdCreate(@Param("updateDO") UploadInfoDO updateDO, @Param("userIdCreate") Long userIdCreate);

        public Integer deleteByUserIdCreate( @Param("userIdCreate") Long userIdCreate);




        public List<UploadInfoDO> listByInUserIdCreate(@Param("userIdCreateList") Collection<Long> userIdCreateList,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByInUserIdCreate(@Param("userIdCreateList") Collection<Long> userIdCreateList,@Param("fieldNames") String[] fieldNames);

        public Integer countByInUserIdCreate(@Param("userIdCreateList") Collection<Long> userIdCreateList);

        public default UploadInfoDO singleResultByInUserIdCreate(Collection<Long> userIdCreateList,String[] fieldNames){
             List<UploadInfoDO> list=this.listByInUserIdCreate(userIdCreateList,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByInUserIdCreate(Collection<Long> userIdCreateList, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByInUserIdCreate(userIdCreateList,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByInUserIdCreate(@Param("updateDO") UploadInfoDO updateDO, @Param("userIdCreateList") Collection<Long> userIdCreateList);

        public Integer updateAllFieldsByInUserIdCreate(@Param("updateDO") UploadInfoDO updateDO, @Param("userIdCreateList") Collection<Long> userIdCreateList);

        public Integer deleteByInUserIdCreate( @Param("userIdCreateList") Collection<Long> userIdCreateList);

        public List<UploadInfoDO> listByUserIdModified(@Param("userIdModified") Long userIdModified,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByUserIdModified(@Param("userIdModified") Long userIdModified,@Param("fieldNames") String[] fieldNames);

        public Integer countByUserIdModified(@Param("userIdModified") Long userIdModified);

        public default UploadInfoDO singleResultByUserIdModified(Long userIdModified,String[] fieldNames){
             List<UploadInfoDO> list=this.listByUserIdModified(userIdModified,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByUserIdModified(Long userIdModified, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByUserIdModified(userIdModified,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByUserIdModified(@Param("updateDO") UploadInfoDO updateDO, @Param("userIdModified") Long userIdModified);

        public Integer updateAllFieldsByUserIdModified(@Param("updateDO") UploadInfoDO updateDO, @Param("userIdModified") Long userIdModified);

        public Integer deleteByUserIdModified( @Param("userIdModified") Long userIdModified);




        public List<UploadInfoDO> listByInUserIdModified(@Param("userIdModifiedList") Collection<Long> userIdModifiedList,@Param("fieldNames") String[] fieldNames);

        @MapKey("id")
        public Map<Long,UploadInfoDO> mapByInUserIdModified(@Param("userIdModifiedList") Collection<Long> userIdModifiedList,@Param("fieldNames") String[] fieldNames);

        public Integer countByInUserIdModified(@Param("userIdModifiedList") Collection<Long> userIdModifiedList);

        public default UploadInfoDO singleResultByInUserIdModified(Collection<Long> userIdModifiedList,String[] fieldNames){
             List<UploadInfoDO> list=this.listByInUserIdModified(userIdModifiedList,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByInUserIdModified(Collection<Long> userIdModifiedList, Function<UploadInfoDO, T> mapper, String[] fieldNames){
             List<UploadInfoDO> list=this.listByInUserIdModified(userIdModifiedList,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByInUserIdModified(@Param("updateDO") UploadInfoDO updateDO, @Param("userIdModifiedList") Collection<Long> userIdModifiedList);

        public Integer updateAllFieldsByInUserIdModified(@Param("updateDO") UploadInfoDO updateDO, @Param("userIdModifiedList") Collection<Long> userIdModifiedList);

        public Integer deleteByInUserIdModified( @Param("userIdModifiedList") Collection<Long> userIdModifiedList);


}
